/*!
 * Otter.js v1.0.0
 * (c) 2017-2017 Billy King
 * Released under the MIT License.
 */


// ;(function($,window,document,undefined){


// })(jQuery,window,document);

;(function (global, factory) {
    //开启严格模式，规范代码，提高浏览器运行效率
    "use strict";


    var options = {
        el: '#ot',
        shapes : [
            {
                type: 'rect',
                id : 'id',
                title: {
                    type: 'inside',
                    text: '示例',
                    position: 'center'
                    // ……
                },
            }
        ]
    };
    



    function intOpt(op){
        // if (typeof op === 'object')
        return typeof op;
    }

    //定义一个类，通常首字母大写
    var Otter = function(el) {
        this.el = typeof el === "string" ? document.querySelector(el) : el;
        // this.setBg('#d00');
        var t = { el: 'pro' };
        // for(var p in t){
        //     options[p] = t[p];
        // }

        // this.setOption(t);
        // alert(options.el);
        console.log('ot参数：%s', arguments[0]);
    };
    //覆写原型链，给继承者提供方法
    Otter.prototype = {
        init: function() {
            //解析模型引擎

        },
        setBg: function(bg) {
            this.el.style.background = bg;
        },
        setOption: function(op) {
            options.call(this);
            op.call(this);
        },
    };
    //兼容CommonJs规范
    if (typeof module !== 'undefined' && module.exports) module.exports = Otter;
    //兼容AMD/CMD规范
    if (typeof define === 'function') define(function() { return Otter; });
    //注册全局变量，兼容直接使用script标签引入该插件
    global.Otter = Otter;






  // typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
	// typeof define === 'function' && define.amd ? define(factory) :
  // (global.Otter = factory());

  //this，在浏览器环境指window，在nodejs环境指global
  //使用this而不直接用window/global是为了兼容浏览器端和服务端
  //将this传进函数体，使全局变量变为局部变量，可缩短函数访问全局变量的时间
})(this
  , (function () { 'use strict';



        



})
);


//对象继承

    // function Class10()
    // {
    //     this.showAdd = function()
    //     {
    //         alert('111');
    //     }
    //     this.showSub = function()
    //     {
    //         alert('222');
    //     }
    // }

    // function Class11()
    // {
    //     this.showAdd = function()
    //     {
    //         alert('333');
    //     }
    // }

    // function Class2()
    // {
    //     Class10.call(this);
    //     Class11.call(this);
    // }

    // new Class2().showAdd(); 

    // var options = function(el) {
    //     el = '#ot',
    //     shapes = [
    //         {
    //             type: 'rect',
    //             id : 'id',
    //             title: {
    //                 type: 'inside',
    //                 text: '示例',
    //                 position: 'center'
    //                 // ……
    //             },
    //         }
    //     ]
    // };
    
    var options = {
        el : ['#ot','ttt'],
        shapes : [
            {
                type: 'rect',
                id : 'id',
                title: {
                    type: 'inside',
                    text: '示例',
                    position: 'center'
                    // ……
                },
            }
        ]
    };

    var op = {
        el: ['#ot2','ddd','eee'],
    }
    


    //常用检测函数
    function isDefined(x) { return x !== null && x !== undefined; } 
    function isObject(x) { return (typeof x === "function" || (typeof x === "object" && x !== null)); } 
    function isObject2(x) { return x === Object(x); }
    function wtObject(x) { return Object.prototype.toString.call(x); }//Null Object Array Date RegExp
    //不同框架（iframe）中创建的数组不会相互共享其prototype属性
    // function isArray(x){ return x instanceof Array; }
    // function isArray(x){ return typeof x == "object" && x.constructor == Array; }
    function isArray(x){ return wtObject(x) === "[object Array]"; }
    function getTypeName(x) { 
        var typeName = typeof x; 
        switch(typeName) { 
            case "undefined": case "boolean": case "number": case "string": return typeName; 
            case "object": if (x === null) { return "null"; } else return "object";
            default: throw new TypeError("参数不是一个原始值: " + x); 
        } 
    }
    // * __getClass(5); // => "Number"
    // * __getClass({}); // => "Object"
    // * __getClass(/foo/); // => "RegExp"
    // * __getClass(''); // => "String"
    // * __getClass(true); // => "Boolean"
    // * __getClass([]); // => "Array"
    // * __getClass(undefined); // => "Window"
    // * __getClass(Element); // => "Constructor"
    function __getType(object){ return Object.prototype.toString.call(object).match(/^\[object\s(.*)\]$/)[1];};

    var is = {
        types : ["Array", "Boolean", "Date", "Number", "Object", "RegExp", "String", "Window", "HTMLDocument"]
    };
    for(var i = 0, c; c = is.types[i ++ ]; ) {
        is[c] = (function(type) {
            return function(obj) {
                return Object.prototype.toString.call(obj) == "[object " + type + "]";
            }
        })(c);
    }
    //即便把option写成类，也无法保证每个属性下的层中的属性被正常继承，而不是无脑覆盖。 
    //关于深度复制，可参照jq $.extend()，而事实此项目的设计并不适用echart 的 option：
    //对于空的[]对象，虽然原型里没有，但设置的时候还是得按照模板来封装，这个模板配置文件定义在内部还是外部定义？
    function clone(o1,o2){
        for(var key in o2){
            if(isObject(o2[key])) {
                // o1[key] = {};
                if (isObject(o1[key])) clone(o1[key],o2[key])
            }
            else{
                o1[key] = o2[key];
            }
        }
        return o1;
    }
    clone(options,op)
                console.log(__getClass([]));
    function intOpt(op){ 
    }   